package com.scedu.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.BitFieldSubCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * redisTemplate封装
 *
 *  @author zjjlive@dist.com.cn
 */
@Component
@Slf4j
public class RedisUtils {

    //@Autowired
     @Resource
    private RedisTemplate<String, Object> redisTemplate;

    public static RedisUtils redisUtils;




    /**
     * 初始化
     */
    @PostConstruct
    public void init() {

        redisUtils = this;
        redisUtils.redisTemplate = this.redisTemplate;

    }

    /**
     * 查询key，支持模糊查询
     *
     * @param key
     */
    public static Set<String> keys(String key) {
        return redisUtils.redisTemplate.keys(key);
    }

    /**
     * 获取值
     *
     * @param key
     */
    public static Object get(String key) {
        return redisUtils.redisTemplate.opsForValue().get(key);
    }

    /**
     * 设置值
     *
     * @param key
     * @param value
     */
    public static void set(String key, String value) {
        redisUtils.redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 设置值，并设置过期时间
     *
     * @param key
     * @param value
     * @param expire 过期时间，单位秒
     */
    public static void set(String key, String value, Long expire) {


        redisUtils.redisTemplate.opsForValue().set(key, value, expire, TimeUnit.SECONDS);
    }

    /**
     * 删出key
     *
     * @param key
     */
    public static void delete(String key) {
        redisUtils.redisTemplate.opsForValue().getOperations().delete(key);
    }

    /**
     * 设置对象
     *
     * @param key     key
     * @param hashKey hashKey
     * @param object  对象
     */
    public static void hset(String key, String hashKey, Object object) {
        redisUtils.redisTemplate.opsForHash().put(key, hashKey, object);
    }

    /**
     * 设置对象
     *
     * @param key     key
     * @param hashKey hashKey
     * @param object  对象
     * @param expire  过期时间，单位秒
     */
    public static void hset(String key, String hashKey, Object object, Integer expire) {
        redisUtils.redisTemplate.opsForHash().put(key, hashKey, object);
        redisUtils.redisTemplate.expire(key, expire, TimeUnit.SECONDS);
    }

    /**
     * 设置HashMap
     *
     * @param key key
     * @param map map值
     */
    public static void hset(String key, HashMap<String, Object> map) {
        redisUtils.redisTemplate.opsForHash().putAll(key, map);
    }

    /**
     * key不存在时设置值
     *
     * @param key
     * @param hashKey
     * @param object
     */
    public static void hsetAbsent(String key, String hashKey, Object object) {
        redisUtils.redisTemplate.opsForHash().putIfAbsent(key, hashKey, object);
    }

    /**
     * 获取Hash值
     *
     * @param key
     * @param hashKey
     * @return
     */
    public static Object hget(String key, String hashKey) {
        return redisUtils.redisTemplate.opsForHash().get(key, hashKey);
    }

    /**
     * 获取key的所有值
     *
     * @param key
     * @return
     */
    public static Object hget(String key) {
        return redisUtils.redisTemplate.opsForHash().entries(key);
    }

    /**
     * 删除key的所有值
     *
     * @param key
     */
    public static void deleteKey(String key) {
        redisUtils.redisTemplate.opsForHash().getOperations().delete(key);
    }

    /**
     * 判断key下是否有值
     *
     * @param key
     */
    public static Boolean hasKey(String key) {
        return redisUtils.redisTemplate.opsForHash().getOperations().hasKey(key);
    }

    /**
     * 判断key和hasKey下是否有值
     *
     * @param key
     * @param hasKey
     */
    public static Boolean hasKey(String key, String hasKey) {
        return redisUtils.redisTemplate.opsForHash().hasKey(key, hasKey);
    }

    /**
     * 取得序列值的下一个，增加 value
     *
     * @param key
     * @param value
     * @return
     */
    public static Long getSeqNext(String key, long value) {
        return redisUtils.redisTemplate.execute((RedisCallback<Long>) connection -> {
            return connection.incrBy(key.getBytes(), value);
        });

    }
    /**
     * 设置超时时间
     *
     * @param key
     * @param seconds
     */
    public static void expire(String key, int seconds) {
        redisUtils.redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
    }

    /**
     * 对 key 所储存的字符串值，获取指定偏移量上的位(bit)
     *
     * @param key
     * @param offset
     * @return
     */
    public static Boolean getBit(String key, long offset) {
        return redisUtils.redisTemplate.opsForValue().getBit(key, offset);
    }
    /**
     * 设置key 所储存的字符串值，设置指定偏移量上的位(bit)
     *
     * @param key
     * @param offset
     * @returns
     */
    public static boolean setBit(String key, long offset, boolean value) {
        return redisUtils.redisTemplate.opsForValue().setBit(key, offset, value);

    }
    /**
     * 统计bit位为1的总数
     * @param key
     */
    public static Long bitCount(String key, int start, int end) {
        return redisUtils.redisTemplate.execute((RedisCallback<Long>) con -> con.bitCount(key.getBytes(), start, end));
    }

    public static List<Long> bitfield(String buildSignKey, int limit ,int  offset) {
        log.info(String.valueOf(BitFieldSubCommands.BitFieldType.unsigned(limit)));
        return (List<Long>) redisUtils.redisTemplate.execute((RedisCallback<List<Long> >) con ->
                con.bitField(buildSignKey.getBytes(),
                        BitFieldSubCommands.create().get(BitFieldSubCommands.BitFieldType.unsigned(limit)).valueAt(offset)));
    }

}

